package com.qingcheng.service.impl;

import com.alibaba.dubbo.config.annotation.Reference;
import com.alibaba.dubbo.config.annotation.Service;
import com.qingcheng.pojo.goods.Category;
import com.qingcheng.pojo.goods.Sku;
import com.qingcheng.pojo.order.Order;
import com.qingcheng.pojo.order.OrderItem;
import com.qingcheng.service.goods.CategoryService;
import com.qingcheng.service.goods.SkuService;
import com.qingcheng.service.order.CartService;
import com.qingcheng.service.order.PreferentialService;
import com.qingcheng.util.CacheKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

import java.util.*;
import java.util.stream.Collectors;

@Service
public class CartserviceImpl implements CartService {
    @Autowired
    private PreferentialService preferentialService;
    @Reference
    private SkuService skuService;
    @Reference
    private CategoryService categoryService;
    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public List<Map<String, Object>> findCartList(String username) {
        //从ridis中获取用户购物车信息
        List<Map<String, Object>> cartList = (List<Map<String, Object>>) redisTemplate.boundHashOps(CacheKey.CART_LIST).get(username);
        if (cartList == null) {
            cartList = new ArrayList<Map<String, Object>>();
        }
        return cartList;
    }

    /**
     * 添加购物车
     *
     * @param username 用户名
     * @param skuId    商品ID
     * @param num      数量
     */
    @Override
    public void addItem(String username, String skuId, Integer num) {
        //获取该用户购物车信息
        List<Map<String, Object>> cartList = findCartList(username);
        //遍历购物车信息，判断是否存在该商品
        Boolean flag = false;
        for (Map<String, Object> map : cartList) {
            OrderItem orderItem = (OrderItem) map.get("item");
            if (orderItem.getSkuId().equals(skuId)) {//存在该商品
                if (orderItem.getNum() <= 0) {//数量不对
                    cartList.remove(map);

                    flag = true;
                    break;

                }
                //计算单个商品的重量
                int weight = orderItem.getWeight() / orderItem.getWeight();
                orderItem.setNum(orderItem.getNum() + num); //数量累加
                orderItem.setMoney(orderItem.getNum() * orderItem.getPrice());//金额计算
                orderItem.setWeight(weight * orderItem.getNum());//重量计算
                if (orderItem.getNum() <= 0) { //如果数量小于等于0
                    cartList.remove(map);//购物车项删除
                }


                flag = true;
                break;
            }
        }
        System.out.println(skuId);
        //没有该商品
        if (flag == false) {
            Sku sku = skuService.findById(skuId);
            if (sku == null) {
                throw new RuntimeException("商品不存在");
            }
            if (!"1".equals(sku.getStatus())) {
                throw new RuntimeException("商品状态不合法");
            }
            if (num <= 0) {
                throw new RuntimeException("商品数量不合法");
            }


            OrderItem orderItem = new OrderItem();
            orderItem.setSkuId(skuId);
            orderItem.setSpuId(sku.getSpuId());
            orderItem.setNum(num);
            orderItem.setImage(sku.getImage());
            orderItem.setPrice(sku.getPrice());
            orderItem.setName(sku.getName());
            orderItem.setMoney(orderItem.getPrice() * num);//金额计算
            if (sku.getWeight() == null) {
                sku.setWeight(0);
            }
            orderItem.setWeight(sku.getWeight() * num);//重量计算


            //商品分类，缓存优化
            orderItem.setCategoryId3(sku.getCategoryId());
            Category category3 = (Category) redisTemplate.boundHashOps(CacheKey.CATEGORY).get(sku.getCategoryId());
            if (category3 == null) {
                //缓存中没有数据,要往缓存中添加数据
                //从数据库查询到该分类
                category3 = categoryService.findById(sku.getCategoryId());
                redisTemplate.boundHashOps(CacheKey.CATEGORY).put(sku.getCategoryId(), category3);
            }
            orderItem.setCategoryId2(category3.getParentId());

            Category category2 = (Category) redisTemplate.boundHashOps(CacheKey.CATEGORY).get(category3.getParentId());
            if (category2 == null) {
                category2 = categoryService.findById(category3.getParentId());
                redisTemplate.boundHashOps(CacheKey.CATEGORY).put(category3.getParentId(), category2);
            }
            orderItem.setCategoryId1(category2.getParentId());


            Map map = new HashMap();
            map.put("item", orderItem);
            map.put("checked", true);//默认选中
            cartList.add(map);

        }


        //往redis中添加
        redisTemplate.boundHashOps(CacheKey.CART_LIST).put(username, cartList);

    }

    /**
     * 更改选中状态
     *
     * @param username
     * @param skuId
     * @param checked
     * @return
     */
    @Override
    public boolean updateChecked(String username, String skuId, boolean checked) {
        //获取该用户购物车信息
        List<Map<String, Object>> cartList = findCartList(username);
        //定义返回状态是否成功
        boolean isOk = false;
        //遍历购物车信息判断是否存在该商品
        for (Map<String, Object> map : cartList) {
            OrderItem orderItem = (OrderItem) map.get("item");
            if (orderItem.getSkuId().equals(skuId)) {
                //说明有改商品，就是对该商品的选中状态做操作
                map.put("checked", checked);
                isOk = true;
                break;
            }
        }
        //如果操作成功，就更新缓存
        if (isOk) {
            redisTemplate.boundHashOps(CacheKey.CART_LIST).put(username, cartList);
        }

        return isOk;
    }

    /**
     * 删除选中的购物车
     *
     * @param username
     */
    @Override
    public void deleteCheckedCart(String username) {
        //用Stream流删选未被选中的商品
        List<Map<String, Object>> cartList = findCartList(username).stream().filter(cart -> (boolean) cart.get("checked") == false).collect(Collectors.toList());
        redisTemplate.boundHashOps(CacheKey.CART_LIST).put(username, cartList);//存入缓存

    }

    /**
     * 计算当前选中的购物车的优惠金额
     *
     * @param
     * @return
     */
    @Override
    public int preferential(String username) {
        //获取选中的购物车 List<OrderItem> List<Map>
        List<OrderItem> orderItemList = findCartList(username).stream()
                .filter(cart -> (boolean) cart.get("checked") == true)
                .map(cart -> (OrderItem) cart.get("item"))
                .collect(Collectors.toList());
        //按分类聚合统计每个分类的金额 group by
        Map<Integer,IntSummaryStatistics> cartMap = orderItemList.stream()
                .collect(Collectors.groupingBy(OrderItem::getCategoryId3,
                        Collectors.summarizingInt(OrderItem::getMoney)));
        //循环结果，统计每个分类的优惠金额，并累加
        int allPreMoney = 0;//累计优惠金额
        for (Integer categoryId:cartMap.keySet()) {
            // 获取品类的消费金额
            int money=(int)cartMap.get(categoryId).getSum();
            int preMoney=preferentialService.findPreMoneyByCategoryId(categoryId, money); //获取优惠金额
            System.out.println("分类:" + categoryId + "消费金额:" + money + "优惠金额:" + preMoney);
            allPreMoney += preMoney;
        }
        return allPreMoney;
    }

    /**
     * 查询新的购物车信息
     * @param username
     * @return
     */
    @Override
    public List<Map<String, Object>> findNewOrderItemList(String username) {
        //获取之前的购物车信息
        List<Map<String, Object>> cartList = findCartList(username);
        //循环购物车列表信息获取商品详细信息更改价格和总价
        for (Map<String, Object> cart : cartList) {
            OrderItem orderItem =(OrderItem) cart.get("item");
            //获取当前商品对象信息
            Sku sku = skuService.findById(orderItem.getSkuId());
            //更新最新的商品信息
            orderItem.setPrice(sku.getPrice());//更新商品最新单价
            orderItem.setMoney(sku.getPrice()*orderItem.getNum());//更新最新的总价
        }

        //存入缓存更新
        redisTemplate.boundHashOps(CacheKey.CART_LIST).put(username,cartList);
        return cartList;
    }


}
